const { spawn } = require('child_process');
const axios = require('axios');

/**
 * 客户端脚本启动管理器
 * 负责从服务器获取配置并启动基础脚本
 */
class ScriptLauncher {
    constructor() {
        this.baseUrl = process.env.API_BASE_URL || 'http://localhost:8080/api';
        this.runningScripts = new Map(); // 存储正在运行的脚本进程
    }

    /**
     * 从服务器获取系统配置
     */
    async getSystemSettings() {
        try {
            const response = await axios.get(`${this.baseUrl}/system/settings`);
            const settings = {};

            // 解析所有配置
            response.data.data.forEach(setting => {
                try {
                    settings[setting.settingKey] = JSON.parse(setting.settingValue);
                } catch (e) {
                    console.error(`解析配置失败: ${setting.settingKey}`, e);
                }
            });

            return settings;
        } catch (error) {
            console.error('获取系统配置失败:', error);
            // 返回默认配置
            return {
                random_sleep_config: { enabled: true, min_seconds: 30, max_seconds: 120 },
                monitor_config: { enabled: true, slippage_threshold: 0.0003 },
                notification_config: { webhook_url: '', enabled: true }
            };
        }
    }

    /**
     * 启动指定账号的交易脚本
     */
    async launchScript(accountId, scriptName = 'auto-trade.js') {
        try {
            // 检查是否已经在运行
            if (this.runningScripts.has(accountId)) {
                console.log(`账号 ${accountId} 的脚本已在运行中`);
                return;
            }

            // 获取系统配置
            const systemSettings = await this.getSystemSettings();

            // 构建启动命令参数
            const args = [
                scriptName,
                `--account-id=${accountId}`,
                `--sleep-config='${JSON.stringify(systemSettings.random_sleep_config)}'`
            ];

            console.log(`启动脚本: node ${args.join(' ')}`);

            // 启动脚本进程
            const scriptProcess = spawn('node', args, {
                stdio: ['pipe', 'pipe', 'pipe'],
                cwd: process.cwd()
            });

            // 监听进程输出
            scriptProcess.stdout.on('data', (data) => {
                console.log(`[账号${accountId}] ${data.toString().trim()}`);
            });

            scriptProcess.stderr.on('data', (data) => {
                console.error(`[账号${accountId}][ERROR] ${data.toString().trim()}`);
            });

            scriptProcess.on('close', (code) => {
                console.log(`[账号${accountId}] 脚本退出，退出码: ${code}`);
                this.runningScripts.delete(accountId);
            });

            scriptProcess.on('error', (error) => {
                console.error(`[账号${accountId}] 脚本启动失败:`, error);
                this.runningScripts.delete(accountId);
            });

            // 记录运行中的脚本
            this.runningScripts.set(accountId, {
                process: scriptProcess,
                startTime: new Date(),
                scriptName: scriptName
            });

            console.log(`账号 ${accountId} 的脚本启动成功`);

        } catch (error) {
            console.error(`启动账号 ${accountId} 脚本失败:`, error);
        }
    }

    /**
     * 停止指定账号的脚本
     */
    async stopScript(accountId) {
        const runningScript = this.runningScripts.get(accountId);
        if (!runningScript) {
            console.log(`账号 ${accountId} 的脚本未在运行`);
            return;
        }

        try {
            runningScript.process.kill('SIGTERM');
            console.log(`账号 ${accountId} 的脚本已发送停止信号`);

            // 等待进程退出
            setTimeout(() => {
                if (this.runningScripts.has(accountId)) {
                    console.log(`强制终止账号 ${accountId} 的脚本`);
                    runningScript.process.kill('SIGKILL');
                }
            }, 10000); // 10秒后强制终止

        } catch (error) {
            console.error(`停止账号 ${accountId} 脚本失败:`, error);
        }
    }

    /**
     * 获取运行状态
     */
    getRunningStatus() {
        const status = [];
        for (const [accountId, scriptInfo] of this.runningScripts) {
            status.push({
                accountId: accountId,
                scriptName: scriptInfo.scriptName,
                startTime: scriptInfo.startTime,
                uptime: Date.now() - scriptInfo.startTime.getTime()
            });
        }
        return status;
    }

    /**
     * 重启所有脚本（用于配置更新后）
     */
    async restartAllScripts() {
        console.log('开始重启所有脚本...');

        const runningAccountIds = Array.from(this.runningScripts.keys());

        // 停止所有脚本
        for (const accountId of runningAccountIds) {
            await this.stopScript(accountId);
        }

        // 等待所有脚本停止
        await new Promise(resolve => setTimeout(resolve, 5000));

        // 重新启动所有脚本
        for (const accountId of runningAccountIds) {
            await this.launchScript(accountId);
        }

        console.log('所有脚本重启完成');
    }
}

// 使用示例
async function main() {
    const launcher = new ScriptLauncher();

    // 启动示例
    await launcher.launchScript(1); // 启动账号1的脚本
    await launcher.launchScript(2); // 启动账号2的脚本

    // 显示运行状态
    console.log('当前运行状态:', launcher.getRunningStatus());

    // 处理进程退出信号
    process.on('SIGINT', async () => {
        console.log('接收到退出信号，停止所有脚本...');
        const runningAccountIds = Array.from(launcher.runningScripts.keys());
        for (const accountId of runningAccountIds) {
            await launcher.stopScript(accountId);
        }
        process.exit(0);
    });
}

// 如果直接运行此文件，则执行示例
if (require.main === module) {
    main().catch(console.error);
}

module.exports = ScriptLauncher;